FEXPCalculation.h

Go to the documentation of this file.

// © FEXP, FEXPEnterprise Solver, Ing. Vaclav Rek
// Manages steps of calculation
// Compiler must support C++ ver.14 and later
#ifndef _CFEXPCALCULATION_H_
#define _CFEXPCALCULATION_H_
#include "FEXPCommon.h"
#include "FEXPElement.h"
#include "FEXPResultExport.h"


#define STABILITY_SAFETY_FACTOR 0.96 // safety factor for stability control
#define DEFAULT_TIME_STEP          0 // default initial time step


class ICFEXPExplicitCalcBase
{
public:
  using t_SearchInput  = const std::vector<t_fexpcommon_ct>;
  using t_SearchResult = Ptr<std::vector<Ptr<ICFEXPElementNodeBase>>>;
  using t_Searcher     = std::function<t_SearchResult(t_SearchInput & min_bound, t_SearchInput & max_bound)>;
  ICFEXPExplicitCalcBase(Ptr<ICFEXPDataModelContIntf> model, Ptr<ICFEXPResultExport> exporter, std::function<void()> updater, t_Searcher searcher)
    : _fe_model(model), _geom_map_updater(updater), _geom_map_searcher(searcher), _result_exporter(exporter) { }
  virtual ~ICFEXPExplicitCalcBase() { }

  // pure virtual member functions
  // calculation steps            
  virtual size_t          SimulationTimeIncrement    (size_t thread_id)              = 0;
  virtual bool            CheckEnd                   (size_t thread_id)              = 0;
  virtual void            PrepareDataForNewTimeLevel (size_t thread_id)              = 0;
  virtual void            UpdateModelMapping         (size_t thread_id)              = 0;
  virtual void            GlobalToLocalTransformation(size_t thread_id)              = 0;
  virtual void            CalculateForces            (size_t thread_id)              = 0;
  virtual void            CalculateNewGeometry       (size_t thread_id)              = 0;
  virtual bool            TrySaveResults             (size_t thread_id, bool forced) = 0;
  virtual void            PrintOutResults            (size_t thread_id)              = 0;
  virtual bool            ClearResults               (size_t thread_id)              = 0;
  virtual void            StabilityControl           (size_t thread_id)              = 0;
  virtual t_fexpcommon_ct GetCalculatedCriticTimeStep()                              = 0;
  virtual void            SetNewTimeStep             (t_fexpcommon_ct dt)            = 0;

  static std::string GetCalcBehavOutString(Ptr<ICFEXPElementNodeBase> node, size_t dof);
protected:
  Ptr<ICFEXPDataModelContIntf> get_model          ()                                     { return _fe_model;                    }
  void                         update_geometry_map()                                     { _geom_map_updater();                 }
  t_SearchResult               search_close_nodes (t_SearchInput min, t_SearchInput max) { return _geom_map_searcher(min, max); }
  Ptr<ICFEXPResultExport>      get_result_exporter()                                     { return _result_exporter;             }
private:
  Ptr<ICFEXPDataModelContIntf> _fe_model;
  std::function<void()>        _geom_map_updater;
  t_Searcher                   _geom_map_searcher;
  // export of results
  Ptr<ICFEXPResultExport>      _result_exporter;
};


class CFEXPCalculation
  : public ICFEXPExplicitCalcBase
{
public:
  CFEXPCalculation(Ptr<ICFEXPDataModelContIntf> model, Ptr<ICFEXPResultExport> exporter,
    std::function<void()> updater, t_Searcher searcher, bool network = false)
    : ICFEXPExplicitCalcBase(model, exporter, updater, searcher), _is_network_calc(network)
  {
    _time_step_dt     = t_fexpcommon_ct(FEXPCOMMON_DEFAULT_VALUE);
    _time_step_dt_old = t_fexpcommon_ct(FEXPCOMMON_DEFAULT_VALUE);
    _time_step_dt_min = GET_MAX_FLT_VAL(t_fexpcommon_ct);
  }

  // override virtual base functions for calculation steps
  virtual size_t          SimulationTimeIncrement    (size_t thread_id)                      override;
  virtual bool            CheckEnd                   (size_t thread_id)                      override;
  virtual void            PrepareDataForNewTimeLevel (size_t thread_id)                      override;
  virtual void            UpdateModelMapping         (size_t thread_id)                      override;
  virtual void            GlobalToLocalTransformation(size_t thread_id)                      override;
  virtual void            CalculateForces            (size_t thread_id)                      override;
  virtual void            CalculateNewGeometry       (size_t thread_id)                      override;
  virtual bool            TrySaveResults             (size_t thread_id, bool forced = false) override;
  virtual void            PrintOutResults            (size_t thread_id)                      override;
  virtual bool            ClearResults               (size_t thread_id)                      override;
  virtual void            StabilityControl           (size_t thread_id)                      override;
  virtual t_fexpcommon_ct GetCalculatedCriticTimeStep()                                      override;
  virtual void            SetNewTimeStep             (t_fexpcommon_ct dt)                    override;
protected:
  void save_results_and_export(size_t thread_id, Ptr<ICFEXPDataModelContIntf> reslt_cont);
private:
  bool            _is_network_calc;
  t_fexpcommon_ct _time_step_dt;
  t_fexpcommon_ct _time_step_dt_min;
  t_fexpcommon_ct _time_step_dt_old;

  size_t save_node_result(Ptr<ICFEXPElementNodeBase> node, Ptr<ICFEXPDataModelContIntf> reslt_cont);
  size_t save_elem_connct(Ptr<ICFEXPElementBase>     elem, Ptr<ICFEXPDataModelContIntf> reslt_cont);
};

#endif // !_CFEXPCALCULATION_H_